package com.lantu.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * <p>redis帮助类</p>
 * 类　　名:  RedisHelper
 * 创建时间： 2019/11/11 19:38
 * 变更时间： 2019/11/11 19:38
 * 变 更 人：
 * 变更内容：
 *
 * @author binyuhuang
 * @version 1.0
 */
@Component
@SuppressWarnings("ALL")
public class RedisUtil {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 判断key是否存在
     *
     * @param key
     * @return
     */
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * renqicheng
     * 根据keys批量删除缓存
     *
     * @param keys
     */
    public void deleteKeys(List<String> keys) {
        // 执行批量删除操作时先序列化template

        for (String key : keys) {
            redisTemplate.delete(key);
        }
    }

    /**
     * renqicheng
     * 获取redis中所有的key
     *
     * @return
     */
    public Set<String> listCacheKey() {
        Set<String> set = redisTemplate.keys("*");
        return set;
    }


    /**
     * renqicheng
     * 获取redis中特定前缀的key
     *
     * @return
     */
    public Set<String> listCacheKeyByPrefix(String prefix) {
        Set<String> set = redisTemplate.keys(prefix + "*");
        return set;
    }



    /**
     * 存入普通对象
     *
     * @param key     键
     * @param value   值
     * @param timeout 有效期，单位秒
     */
    public void set(final String key, final Object value, final long timeout) {
        redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    }

    /**
     * 存入普通对象
     *
     * @param key
     * @param value
     */
    public void set(final String key, final Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 获取普通对象
     *
     * @param key 键
     * @return 对象
     */
    public Object get(final String key) {

        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 向redis添加数据
     *
     * @param k1
     * @param k2
     * @param value
     */
    public synchronized void putHash(String k1, String k2, Object value) {
        redisTemplate.opsForHash().put(k1, k2, value);
    }


    /**
     * 获取redis中的数据
     *
     * @param k1
     * @param k2
     * @return
     */
    public Object getHash(Object k1, Object k2) {
        return redisTemplate.opsForHash().get(k1, k2);

    }


    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {

        Boolean ret = redisTemplate.expire(key, timeout, unit);
        return ret != null && ret;
    }

    /**
     * 存储集合
     *
     * @param k
     * @param collection
     */
    public void listRightPushAll(Object k, Collection collection) {
        redisTemplate.opsForList().rightPushAll(k, collection);
    }

    /**
     * 获取集合
     *
     * @param k
     * @return
     */
    public Object listRightPop(Object k) {
        return redisTemplate.opsForList().rightPop(k);
    }

    /**
     * 根据key删除
     *
     * @param k1
     */
    public void delteKey(String k1) {
        redisTemplate.delete(k1);
    }

    /**
     * 删除hash中的小key和值
     *
     * @param k1
     * @param k2
     */
    public void deleteHash(String k1, String k2) {
        redisTemplate.boundHashOps(k1).delete(k2);
    }

    /**
     * 删除指定前缀的KEY
     *
     * @param k1
     * @param prex
     */
    public synchronized void deleteByPrex(String k1, String prex) {
        Set<String> keys = redisTemplate.boundHashOps(k1).keys();
        if (org.apache.commons.collections.CollectionUtils.isNotEmpty(keys)) {
            for (String key : keys
            ) {
                if (key.startsWith(prex)) {
                    redisTemplate.boundHashOps(k1).delete(key);
                }
            }
        }
    }

    /**
     * 删除指定后缀的KEY
     *
     * @param k1S
     * @param prex
     */
    public synchronized void deleteBySuffix(String k1, String prex) {
        Set<String> keys = redisTemplate.boundHashOps(k1).keys();
        if (org.apache.commons.collections.CollectionUtils.isNotEmpty(keys)) {
            for (String key : keys
            ) {
                if (key.endsWith(prex)) {
                    redisTemplate.boundHashOps(k1).delete(key);
                }
            }
        }
    }

    private String getDateStr(long timeStmp) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return dateFormat.format(new Date(timeStmp));
    }
}
